package com.soulless.lazy;

/**
 * 懒汉式单例-简单
 * <p>
 * 优点：
 * 节省了内存。
 * 缺点：
 * 线程不安全，在同一时刻，两个进程可能会同时调用getInstance()。
 *
 * 加了synchronized线程安全，但是影响性能，存在性能瓶颈。
 *
 * 同一个实例时：
 *     1 正常顺序执行。
 *     2 后者覆盖前者情况。
 *
 * 不同实例时：
 *     同时进入条件，按顺序返回。
 * </p>
 *
 * @author zenglei
 * @date 2022/11/16 14:15
 */
public class LazySimpleSingleton {

    private static LazySimpleSingleton instance;

    private LazySimpleSingleton() {}

    /**
     * synchronized 保证线程安全，控制资源永远只有一个线程占用
     * @return
     */
    public synchronized static LazySimpleSingleton getInstance() {
        if (null == instance) {
            instance = new LazySimpleSingleton();
        }
        return instance;
    }

    //region 测试模块
    /**
     * 测试多线程
     * <p>
     *
     * </p>
     *
     * @author zenglei
     * @date 2023/5/29 14:17
     */
    static class LazySimpleSingletonThread implements Runnable {

        public void run() {
            LazySimpleSingleton ins = LazySimpleSingleton.getInstance();
            System.out.println(Thread.currentThread().getName() + " : " + ins);

            /**
             * 执行结果：
             * Thread-0 : com.soulless.lazy.LazySimpleSingleton@8661902
             * Thread-1 : com.soulless.lazy.LazySimpleSingleton@3d797285
             * 实例的hash值有时相同有时不相同，相同时为线程安全的，反之不安全
             */
        }

    }

    /**
     * 多线程测试-单例
     * <p>
     *
     * </p>
     *
     * @author zenglei
     * @date 2023/5/29 14:18
     */
    static class MultiThreadTest {

        public static void main(String[] args) {
            Thread thread1 = new Thread(new LazySimpleSingletonThread());
            Thread thread2 = new Thread(new LazySimpleSingletonThread());
            thread1.start();
            thread2.start();
            System.out.println("End");
        }

    }
    //endregion

}




